Image classification with Google's ViT and Hugging Face 🤗
Fine-tuning a ViT model with Hugging Face.
🔖 Learning objectives
- In A brief introduction to Vision Transfomer (ViT) we will explore the core ideas that define a vision transformer model.
- In Loading the data we will take advantage of the Hugging Face Hub and its libraries to download a cool dataset.
- In EDA with pandas we will use pandas to explore the dataset.
- In Image pre-processing we will learn how to pre-process the images for training.
- In Training we will fine-tune a pre-trained vision transformer to perform a down-stream task.
- In Evaluation we will see how the model peforms after fine-tuning.
- In Data augmentation we will add extra transformations to the pre-processing pipeline to make our model more robust to unseen data.
- Acknowledgments contains the main resources I used as a source of inspiration and learning to write this post.
- Additional resources contains extra materials that I highly recommend to check out.
The Vision Transformer (ViT) is a transformer-based architecture for computer vision tasks proposed in the An Image is Worth 16x16 Words paper by researchers at Google in 2020. The ViT leverages only the encoder part of the original Transformer architecture and each input image is interpreted as a sequence of patch embeddings.
In the pre-processing phase, an image is broken down into a grid of square patches. Each patch is flattened and linearly projected onto a lower-dimensional space. A learnable position embedding is then added to the resulting patch embedding to retain the positional information. These steps are applied at once to each patch forming the image.
Before feeding the sequence of patch embeddings and position embeddings to the encoder, an extra learnable "class" embedding is prepended to the sequence. The last hidden state of this embedding serves as representation of the overall image. A classification head on top of the transformer encoder maps the last hidden state of the class embedding onto the final vector space representing the labels.
In this notebook we will learn how to take a ViT model pre-trained on a large dataset and fine-tune it to perform image classification on a smaller task-specific dataset. We will use the google/vit-base-patch16-224-in21k as a pre-trained model. This checkpoint was generated by pre-training a ViT on ImageNet-21k at a resolution of 224x224. During pre-processing images were converted into sequences of 16x16 patches. And as for the data, we will use the Matthijs/snacks dataset which consists of 6745 images and 20 classes.
We make sure our instance has a GPU and pip install the Hugging Face libraries.
!nvidia-smi
!pip install datasets -Uqq
!pip install transformers[sentencepiece] -Uqq
import numpy as np
import random
import torch
def set_seeds(seed=1234):
"""Set seeds for reproducibility."""
np.random.seed(seed)
random.seed(seed)
torch.manual_seed(seed)
if torch.cuda.is_available():
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
set_seeds(2077)
We can conveniently get access to the dataset using the load_dataset function from the datasets library.
The resulting DatasetDict object already contains a train, validation and test set as Dataset objects. Each dataset has two features: image and label.
Images are PIL.JpegImagePlugin.JpegImageFile objects, whereas labels are simple integers.
We can inspect the content of a Dataset as if we were inspecting a normal list.
from datasets import load_dataset
raw_data = load_dataset('Matthijs/snacks')
raw_data
raw_data['train'][:3]
We can get the full list of labels through the features attribute. They are represented as a ClassLabel object.
Each of the 20 labels represent a kind of snack... Some are healthier than others. 🍭
labels = raw_data['train'].features['label']
labels
Let's visualize some of the images with matplotlib to get a better understanding of the data. The ClassLabel class has a int2str method that allows us to map the IDs to the actual labels.
import matplotlib.pyplot as plt
nrows = 2
ncols = 5
plt.figure(figsize=(ncols*2, nrows*2), dpi=100)
for i in range(1, nrows*ncols + 1):
sample_image = raw_data['train'][i]
plt.subplot(nrows, ncols, i)
plt.imshow(sample_image['image'].resize((128, 128)))
plt.title(labels.int2str(sample_image['label']), fontsize=10)
plt.axis('off')
plt.show()
Probably the reason why we visualized images representing only a single class is because the data is ordered by labels.
Let's plot some images once again, but this time using a random sample.
random_sample = raw_data['train'].shuffle(seed=2077).select(range(100))
nrows = 2
ncols = 5
plt.figure(figsize=(ncols*2, nrows*2), dpi=100)
for i in range(nrows*ncols):
sample_image = random_sample[i]
plt.subplot(nrows, ncols, i+1)
plt.imshow(sample_image['image'].resize((128, 128)))
plt.title(labels.int2str(sample_image['label']), fontsize=10)
plt.axis('off')
plt.show()
Now we're talking!
With Hugging Face DatasetDict and Dataset classes we can convert the data into a pandas.DataFrame object to investigate its content leveraging our knowledge of the pandas library.
We just need to change the output format with the set_format method and grab the entire dataset by slicing the entire dataset with [:].
raw_data.set_format('pandas')
raw_data_pd = raw_data['train'][:]
raw_data_pd.shape
We count the number of images available for each label to check if there is any imbalance. Then we visualize the result as a barplot using seaborn.
samples_count = (
raw_data_pd
.groupby('label')
.count()
.reset_index()
.rename(columns={'image': 'count'})
# .reset_index()
)
# map IDs to labels
samples_count['label'] = samples_count['label'].map(lambda x: labels.int2str(x))
samples_count
import seaborn as sns
sns.set_theme(style='whitegrid', palette='pastel')
plt.figure(dpi=100)
bar = sns.barplot(y='label', x='count', data=samples_count, orient='h')
plt.show()
As we can observe from the table and bar plot above most classes are represented by about 250 images. pineapple is the most common class with 260 images, whereas pretzel is the least represented class with only 154 images.
Overall, we can say this dataset is pretty well balanced.
Before moving to the next section, let's make sure to restore the original format of the data with the reset_format method.
raw_data.reset_format()
As for text, images also require some sort of pre-processing before they can be fed to a ViT. The most basic approach just requires resizing and normalizing the images across the channels with the same statistics used during pre-training.
We will see how to increase the robustness of our model with the help of data augmentation in a section below.
The Hugging Face library provides a ViTFeatureExtractor class that automatically performs resizing and normalization according to the pre-training statistics.
To load the pre-processing pipeline, sometimes referred as feature extractor, we simply pass the google/vit-base-patch16-224-in21k checkpoint as an argument to the from_pretrained method when instantiating the ViTFeatureExtractor object.
It specifies that images need to be resized at a resolution of 224x224 and normalized across channels using image_mean and image_std statistics.
from transformers import ViTFeatureExtractor
checkpoint = 'google/vit-base-patch16-224-in21k'
feature_extractor = ViTFeatureExtractor.from_pretrained(checkpoint)
feature_extractor
We can test the feature extractor by simply passing a sample image as an argument.
What we get in return is a dictionary with a pixel_values key and associated value is a list that contains a numpy.ndarray of shape 3x224x224 representing the pre-processed image.
sample_image = random_sample['image'][0]
sample_image
sample_image_features = feature_extractor(sample_image)
sample_image_features
sample_image_features['pixel_values'][0].shape
We can visually inspect the pre-processed image by first converting the numpy.ndarray into a torch.Tensor and then convert the tensor into a PIL.Image.Image with the help of the transforms.ToPILImage() from the torchvision library.
from torchvision import transforms
import torch
transforms.ToPILImage()(torch.tensor(sample_image_features['pixel_values'][0]))
Now that we have a basic grasp of how the ViT feature extractor works, we can define a function that extract the pixel_values from each data point and apply this function on-the-fly on batches with the set_transform method everytime __getitem__ is called.
We can use the deepcopy function from the copy library to duplicate the datasets and keep the original ones unaltered.
def apply_feature_extractor(examples):
examples['pixel_values'] = [torch.tensor(feature_extractor(image.convert('RGB'))['pixel_values'][0]) for image in examples['image']]
return examples
import copy
data_preprocessed = copy.deepcopy(raw_data)
data_preprocessed.set_transform(apply_feature_extractor)
data_preprocessed
To see the function at work we simply need to access a sample.
data_preprocessed['train'][0]
It seems to work properly. Everytime one or more samples are accessed, the pre-processing function is invoked to generate the pixel_values which are then added to the features.
Just to be 100% sure the pre-processing transformation is working in the right way, let's visualize a couple of images.
nrows = 2
ncols = 5
plt.figure(figsize=(ncols*2, nrows*2), dpi=100)
preprocessed_samples = data_preprocessed['train'].shuffle(seed=2077).select(range(nrows * ncols))
for i in range(nrows*ncols):
preprocessed_sample = preprocessed_samples[i]
plt.subplot(nrows, ncols, i+1)
plt.imshow(transforms.ToPILImage()(torch.tensor(preprocessed_sample['pixel_values'])).resize((128, 128)))
plt.title(labels.int2str(preprocessed_sample['label']), fontsize=10)
plt.axis('off')
plt.show()
It's looking good!
Before moving to the training phase, there is one last step we have to do: rename the label feature as labels because by default the model will look for this specific column to compute the loss.
data_cleaned = data_preprocessed.rename_column('label', 'labels')
data_cleaned
We can get access to a pre-trained ViT model using the ViTForImageClassification class and use its from_pretrained method to load a pre-existing checkpoint.
In addition to the checkpoint, we also need to set num_labels to correctly represent the number of classes in our dataset.
In this way, during initialization the ViTForImageClassification class will replace the default head with a new one intended for our down-stream dataset.
For the sake of completeness, in this specific example we also define the id2label and label2id parameters to map IDs to labels and vice versa, but they are totally optional and they are not as relevant as num_labels.
from transformers import ViTForImageClassification
model = ViTForImageClassification.from_pretrained(
checkpoint,
num_labels=labels.num_classes,
id2label={index: label for index, label in enumerate(labels.names)},
label2id={label: index for index, label in enumerate(labels.names)}
)
By default the training loop reports back only the training and validation loss which from a human perspective can be difficult to interpret.
For this reason, we define a function to compute some of the metrics commonly used in a classification task: accuracy, precision, recall and f1 score.
They are all available through the load_metric function from the datasets library.
We define a function that at each evaluation step will take the validation predictions as input and will report back the metrics we chose.
import numpy as np
from datasets import load_metric
# define function to compute metrics
def compute_metrics_fn(eval_preds):
metrics = dict()
accuracy_metric = load_metric('accuracy')
precision_metric = load_metric('precision')
recall_metric = load_metric('recall')
f1_metric = load_metric('f1')
logits = eval_preds.predictions
labels = eval_preds.label_ids
preds = np.argmax(logits, axis=-1)
metrics.update(accuracy_metric.compute(predictions=preds, references=labels))
metrics.update(precision_metric.compute(predictions=preds, references=labels, average='weighted'))
metrics.update(recall_metric.compute(predictions=preds, references=labels, average='weighted'))
metrics.update(f1_metric.compute(predictions=preds, references=labels, average='weighted'))
return metrics
The TrainingArguments class from the transformers library is responsible for gathering up all the parameters to customize the training loop. The only required parameter is an output_dir to save predictions and checkpoints, but in this case we also specified parameters like the number of epochs, the batch size and how frequently we want to evaluate the model.
By default the remove_unused_columns is set to False so that during training the model automatically drops unwanted features like the image items in our dataset. However, we can't drop this feature yet because the set_transform method and the apply_feature_extractor function we defined earlier require the raw images to generate the pixel_values feature.
That's why we need to explicitly set this parameter to True.
from transformers import TrainingArguments
training_args = TrainingArguments(
output_dir='vit-run#0001',
num_train_epochs=5,
per_device_train_batch_size=16,
per_device_eval_batch_size=16,
save_steps=200,
logging_steps=200,
evaluation_strategy='steps',
eval_steps=200,
load_best_model_at_end=True,
remove_unused_columns=False,
fp16=True
)
The data collator is that piece of code responsible to assemble together individual samples into batches.
Since we instructed the training loop to keep all the features, we can't rely on the DefaultDataCollator from the transformers library anymore. During training it would attempt to feed to the model also the original images, but as we well know at this point, the ViT model only accepts pixel_values and labels as input features.
We can overcome the issue by defining our own collate function. During training and inference the collate function receives as input a list of data points. The length of the list is defined by the batch size.
In this specific example, a data point corresponds to a dictionary with three key-value pairs: image, labels and pixel_values. Knowing that, we define our custom collate function so that it only keeps pixel_values and labels and ignores image.
pixel_values are 3D (channels, height, width) tensors and therefore we bundle them together with torch.stack to form a 4D tensor representing batch size, channels, height and width. labels are just integers and it's sufficient to convert the list containing them into a torch.tensor.
# e.g. examples = [{'image': , 'labels': , 'pixel_values': }]
def collate_fn(examples):
pixel_values = torch.stack([example['pixel_values'] for example in examples])
labels = torch.tensor([example['labels'] for example in examples])
return {'pixel_values': pixel_values, 'labels': labels}
We can test the custom collate function by providing a list of examples.
In this case we assume that a batch includes 8 samples.
collate_test = collate_fn([data_cleaned['train'][i] for i in range(8)])
print(collate_test['pixel_values'].shape)
print(collate_test['labels'])
It returned what we were expecting and so we're good to move on!
The Trainer class from the transformers library is the training loop itself. We provide all the items we've generated so far:
- pre-trained model
- training arguments
- custom collate function
- training and validation dataset
- custom metrics function
from transformers import Trainer
trainer = Trainer(
model,
training_args,
data_collator=collate_fn,
train_dataset=data_cleaned['train'],
eval_dataset=data_cleaned['validation'],
compute_metrics=compute_metrics_fn
)
The train method starts the training process.
💡 It is completely fine to get different numbers from one iteration to another.
trainer.train()
| Step | Training Loss | Validation Loss | Accuracy | Precision | Recall | F1 |
|---|---|---|---|---|---|---|
| 200 | 2.043600 | 1.224619 | 0.929843 | 0.931073 | 0.929843 | 0.929469 |
| 400 | 0.811400 | 0.606548 | 0.930890 | 0.934740 | 0.930890 | 0.931249 |
| 600 | 0.361000 | 0.409591 | 0.936126 | 0.937213 | 0.936126 | 0.936149 |
| 800 | 0.171400 | 0.335438 | 0.927749 | 0.928861 | 0.927749 | 0.927565 |
| 1000 | 0.119500 | 0.310710 | 0.935079 | 0.936808 | 0.935079 | 0.935311 |
| 1200 | 0.084400 | 0.289761 | 0.937173 | 0.938265 | 0.937173 | 0.937235 |
| 1400 | 0.069500 | 0.285235 | 0.938220 | 0.939314 | 0.938220 | 0.938348 |
</div> </div>
The metrics computed for the validation set during training looks promising.
Let's evaluate our fine-tuned ViT on the test set.
trainer.evaluate(data_cleaned['test'])
We can assume as a simple baseline the accuracy achieved by a hypothetical model that always predicts the most common class in the training set. Since in our case the most representative class is pineapple with 260 images and the train set overall contains 4,838 images, with this heuristic we would achieve an train accuracy of about 5.37%.
With the test accuracy well above 90% our fine-tuned ViT is definitely outperforming the baseline and in a real-world scenario it would justify its deployment in production.
We can get a better understanding of the results with the help of a classification report and confusion matrix both from sklearn.
Before doing that, we need to write a function to score each data point and generate the final predictions. First we leverage the predict method of the Trainer class to obtain the logits and then we use numpy.argmax to find the index corresponding to the largest logit.
That index represents the predicted class.
def get_predictions(dataset, model):
raw_preds = model.predict(dataset)
logits = raw_preds.predictions
targets = raw_preds.label_ids
preds = np.argmax(logits, axis=-1)
return (targets, preds)
# get indexes and target labels
targets, preds = get_predictions(data_cleaned['test'], trainer)
from sklearn.metrics import classification_report
print(classification_report(targets, preds, target_names=labels.names))
from sklearn.metrics import ConfusionMatrixDisplay
import matplotlib as mpl
from matplotlib import pyplot as plt
mpl.rc_file_defaults()
fig, ax = plt.subplots(dpi=100)
label_font = {'size':'18'} # Adjust to fit
ConfusionMatrixDisplay.from_predictions(
targets,
preds,
display_labels=labels.names,
cmap='RdPu',
ax=ax
)
plt.xticks(rotation=90)
plt.show()
Previously, we've learned how to pre-process the images with the standard feature extractor imported from Hugging Face.
In this section we will learn how to replace it with a customized pre-processing pipeline that will include additional transformations to increase the variety of images we will present to the model.
Those augmented images will make our model more robust to examples never encountered during training.
For this example we will rely on the transformations available in torchvision.transforms.
In addition to Normalize and ToTensor which were already present in the ViTFeatureExtractor class, we add to our customized pre-processing pipeline RandomResizedCrop, which replaces the standard resizing step, RandomHorizontalFlip and RandomAdjustSharpness. During training, these transformations will have a chance to crop, horizontally split images and change their sharpness.
These are just a few of the transformations available in torchvision.transforms and with a similar logic it is possible to integrate transformations from other libraries, such as albumentations.
It is the task at hand that defines which ones are worth including because with data augmentation we don't want to simply improve variety, we also want to generate plausible images that the model might have a chance to encounter once in production. For example, if we are trying to build a model to classify images of cars, probably applying a vertical flip is not the best option because in normal condition images of upside down cars are not that common. A horizontal flip might be a more suitable option.
from torchvision.transforms import (
Compose,
Normalize,
Resize,
RandomResizedCrop,
RandomHorizontalFlip,
RandomAdjustSharpness,
ToTensor,
ToPILImage
)
When it comes to data augmentation, the dominant approach requires that random transformations are only applied to the train data, whereas the validation and test sets are subject to deterministic augmentations. In doing so, during each epoch the model has a chance to be exposed to slightly different images, but in the evaluation step the model is always scored against the same set of images.
For this example we will follow this strategy.
For resizing and normalization we need to make sure we align with the values used in the feature extractor. We can access the exact numbers through the size, image_mean and image_std attributes.
For all the random transformation, we set the probability of being applied to 0.5.
Finally, we can chain all those transformations together with Compose.
# train
train_aug_transforms = Compose([
RandomResizedCrop(size=feature_extractor.size),
RandomHorizontalFlip(p=0.5),
RandomAdjustSharpness(sharpness_factor=5, p=0.5),
ToTensor(),
Normalize(mean=feature_extractor.image_mean, std=feature_extractor.image_std),
])
# validation/test
valid_aug_transforms = Compose([
Resize(size=(feature_extractor.size, feature_extractor.size)),
ToTensor(),
Normalize(mean=feature_extractor.image_mean, std=feature_extractor.image_std),
])
Let's check both pre-processing pipelines on the sample image we defined earlier.
nrows = 2
ncols = 5
plt.figure(figsize=(ncols*2, nrows*2), dpi=100)
for i in range(1, nrows*ncols + 1):
plt.subplot(nrows, ncols, i)
plt.imshow(ToPILImage()(train_aug_transforms(sample_image)))
plt.axis('off')
plt.show()
nrows = 2
ncols = 5
plt.figure(figsize=(ncols*2, nrows*2), dpi=100)
for i in range(1, nrows*ncols + 1):
plt.subplot(nrows, ncols, i)
plt.imshow(ToPILImage()(valid_aug_transforms(sample_image)))
plt.axis('off')
plt.show()
They both seem to work as expected: the train pipeline produced slightly different variations of the same image, whereas the validation/test pipeline generated the same output at each iteration.
Since we have two distinct transformation pipelines, we need to define two distinct functions as well. Then we pass them to each dataset independently with the set_transform method.
def apply_train_aug_transforms(examples):
examples['pixel_values'] = [train_aug_transforms(img.convert('RGB')) for img in examples['image']]
return examples
def apply_valid_aug_transforms(examples):
examples['pixel_values'] = [valid_aug_transforms(img.convert('RGB')) for img in examples['image']]
return examples
data_preprocessed['train'].set_transform(apply_train_aug_transforms)
data_preprocessed['validation'].set_transform(apply_valid_aug_transforms)
data_preprocessed['test'].set_transform(apply_valid_aug_transforms)
data_preprocessed
Just to be 100% sure everything went well, let's visualize the outputs one last time.
nrows = 2
ncols = 5
plt.figure(figsize=(ncols*2, nrows*2), dpi=100)
for i in range(1, nrows*ncols + 1):
plt.subplot(nrows, ncols, i)
plt.imshow(ToPILImage()(data_preprocessed['train'][0]['pixel_values']))
plt.axis('off')
plt.show()
nrows = 2
ncols = 5
plt.figure(figsize=(ncols*2, nrows*2), dpi=100)
for i in range(1, nrows*ncols + 1):
plt.subplot(nrows, ncols, i)
plt.imshow(ToPILImage()(data_preprocessed['test'][0]['pixel_values']))
plt.axis('off')
plt.show()
Everything is looking good!
data_cleaned = data_preprocessed.rename_column('label', 'labels')
data_cleaned
As for the training nothing will change.
model = ViTForImageClassification.from_pretrained(
checkpoint,
num_labels=labels.num_classes,
id2label={index: label for index, label in enumerate(labels.names)},
label2id={label: index for index, label in enumerate(labels.names)}
)
from transformers import TrainingArguments
training_args = TrainingArguments(
output_dir='vit-run#0002',
num_train_epochs=5,
per_device_train_batch_size=16,
per_device_eval_batch_size=16,
save_steps=200,
logging_steps=200,
evaluation_strategy='steps',
eval_steps=200,
load_best_model_at_end=True,
remove_unused_columns=False,
fp16=True
)
from transformers import Trainer
trainer = Trainer(
model,
training_args,
data_collator=collate_fn,
train_dataset=data_cleaned['train'],
eval_dataset=data_cleaned['validation'],
compute_metrics=compute_metrics_fn
)
trainer.train()
| Step | Training Loss | Validation Loss | Accuracy | Precision | Recall | F1 |
|---|---|---|---|---|---|---|
| 200 | 2.170600 | 1.361377 | 0.905759 | 0.909594 | 0.905759 | 0.904600 |
| 400 | 1.055500 | 0.757420 | 0.919372 | 0.923756 | 0.919372 | 0.919631 |
| 600 | 0.668000 | 0.522591 | 0.934031 | 0.936073 | 0.934031 | 0.934357 |
| 800 | 0.482800 | 0.422806 | 0.935079 | 0.937105 | 0.935079 | 0.935202 |
| 1000 | 0.414700 | 0.354634 | 0.938220 | 0.939484 | 0.938220 | 0.938099 |
| 1200 | 0.353700 | 0.316942 | 0.946597 | 0.947634 | 0.946597 | 0.946709 |
| 1400 | 0.320300 | 0.305057 | 0.949738 | 0.950471 | 0.949738 | 0.949751 |
</div> </div>
Let's see how the model performs on the test set.
trainer.evaluate(data_cleaned['test'])
Even though this second model achieves a slightly lower test accuracy, it is probably more robust than the previous one thanks to the augmented images.
It's also important to notice that at the end of this second run the training loss is still larger than the validation loss. This might be a sign that the model is underfitting the training set and there might still be room for improvement by training for additional epochs.
targets, preds = get_predictions(data_cleaned['test'], trainer)
from sklearn.metrics import classification_report
print(classification_report(targets, preds, target_names=labels.names))
from sklearn.metrics import ConfusionMatrixDisplay
import matplotlib as mpl
from matplotlib import pyplot as plt
mpl.rc_file_defaults()
fig, ax = plt.subplots(dpi=100)
label_font = {'size':'18'} # Adjust to fit
ConfusionMatrixDisplay.from_predictions(
targets,
preds,
display_labels=labels.names,
cmap='RdPu',
ax=ax
)
label_font = {'size':'10'} # Adjust to fit
ax.set_xlabel('Predicted labels', fontdict=label_font)
ax.set_ylabel('Observed labels', fontdict=label_font)
ax.tick_params(axis = 'both', labelsize=7)
plt.xticks(rotation=90)
plt.show()
In this post we've learned that the ViT is an encoder-based architecture designed to perform computer vision tasks. One of the most interesting aspects is how images are pre-processed and fed to the model: each image is divided into 16x16 patches and those patches are transformed into a sequence of embeddings to form the input data.
Then we've discovered how to take a pre-trained model from Hugging Face and fine-tune it to perform image classification on a task-specific dataset.
Finally we've learned how to enhance the default pre-processing pipeline with additional data augmentation transformations to fine-tune a more performing and robust model.
- A big shout out to the Hugging Face community. In particular, I would like to personally thank Niels Rogge and Nate Raw for their contributions to the broader community. Niels' notebook and Nate's post were fundamental sources of inspiration to write this blog post. A special thanks also to Matthijs Hollemans for making available the snacks dataset on the Hub.
- Sergios Karagiannakos' ViT tutorial was another great source of knowledge and inspiration.
- The ViT paper and Google AI's blog post are two great resources to explore more in depth the theory behind the ViT.
- If you prefer videos over articles, then Yannic Kilcher's ViT paper explanation might be the right resource for you to learn more about the ViT architecture.
- The Hugging Face Course and Docs are the go-to resources to clarify doubts and learn more about the Hugging Face libraries in general.